/* csvorbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk<ymnk@jcraft.com>
 * Ported to C# from JOrbis by: Mark Crichton <crichton@gimp.org> 
 *   
 * Thanks go to the JOrbis team, for licencing the code under the
 * LGPL, making my job a lot easier.
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
   
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


using System;
using csogg;

namespace csvorbis 
{
	class StaticCodeBook
	{
		internal int   dim;            // codebook dimensions (elements per vector)
		internal int   entries;        // codebook entries
		internal int[] lengthlist;     // codeword lengths in bits

		// mapping
		internal int   maptype;        // 0=none
		// 1=implicitly populated values from map column 
		// 2=listed arbitrary values

		// The below does a linear, single monotonic sequence mapping.
		internal int   q_min;       // packed 32 bit float; quant value 0 maps to minval
		internal int   q_delta;     // packed 32 bit float; val 1 - val 0 == delta
		internal int   q_quant;     // bits: 0 < quant <= 16
		internal int   q_sequencep; // bitflag

		// additional information for log (dB) mapping; the linear mapping
		// is assumed to actually be values in dB.  encodebias is used to
		// assign an error weight to 0 dB. We have two additional flags:
		// zeroflag indicates if entry zero is to represent -Inf dB; negflag
		// indicates if we're to represent negative linear values in a
		// mirror of the positive mapping.

		internal int[] quantlist;  // map == 1: (int)(entries/dim) element column map
		// map == 2: list of dim*entries quantized entry vals

		// encode helpers
		internal EncodeAuxNearestMatch nearest_tree;
		internal EncodeAuxThreshMatch  thresh_tree;

		internal StaticCodeBook(){}
		internal StaticCodeBook(int dim, int entries, int[] lengthlist,
			int maptype, int q_min, int q_delta, 
			int q_quant, int q_sequencep, int[] quantlist,
			//EncodeAuxNearestmatch nearest_tree,
			Object nearest_tree,
			// EncodeAuxThreshmatch thresh_tree,
			Object thresh_tree
			) : this()
		{
			this.dim=dim; this.entries=entries; this.lengthlist=lengthlist;
			this.maptype=maptype; this.q_min=q_min; this.q_delta=q_delta;
			this.q_quant=q_quant; this.q_sequencep=q_sequencep; 
			this.quantlist=quantlist;
		}

		internal int pack(csBuffer opb)
		{
			int i;
			bool ordered=false;

			opb.write(0x564342,24);
			opb.write(dim, 16);
			opb.write(entries, 24);

			// pack the codewords.  There are two packings; length ordered and
			// length random.  Decide between the two now.
  
			for(i=1;i<entries;i++)
			{
				if(lengthlist[i]<lengthlist[i-1])break;
			}
			if(i==entries)ordered=true;
  
			if(ordered)
			{
				// length ordered.  We only need to say how many codewords of
				// each length.  The actual codewords are generated
				// deterministically

				int count=0;
				opb.write(1,1);               // ordered
				opb.write(lengthlist[0]-1,5); // 1 to 32

				for(i=1;i<entries;i++)
				{
					int _this=lengthlist[i];
					int _last=lengthlist[i-1];
					if(_this>_last)
					{
						for(int j=_last;j<_this;j++)
						{
							opb.write(i-count,ilog(entries-count));
							count=i;
						}
					}
				}
				opb.write(i-count,ilog(entries-count));
			}
			else
			{
				// length random.  Again, we don't code the codeword itself, just
				// the length.  This time, though, we have to encode each length
				opb.write(0,1);   // unordered
    
				// algortihmic mapping has use for 'unused entries', which we tag
				// here.  The algorithmic mapping happens as usual, but the unused
				// entry has no codeword.
				for(i=0;i<entries;i++)
				{
					if(lengthlist[i]==0)break;
				}

				if(i==entries)
				{
					opb.write(0,1); // no unused entries
					for(i=0;i<entries;i++)
					{
						opb.write(lengthlist[i]-1,5);
					}
				}
				else
				{
					opb.write(1,1); // we have unused entries; thus we tag
					for(i=0;i<entries;i++)
					{
						if(lengthlist[i]==0)
						{
							opb.write(0,1);
						}
						else
						{
							opb.write(1,1);
							opb.write(lengthlist[i]-1,5);
						}
					}
				}
			}

			// is the entry number the desired return value, or do we have a
			// mapping? If we have a mapping, what type?
			opb.write(maptype,4);
			switch(maptype)
			{
				case 0:
					// no mapping
					break;
				case 1:
				case 2:
					// implicitly populated value mapping
					// explicitly populated value mapping
					if(quantlist==null)
					{
						// no quantlist?  error
						return(-1);
					}
    
					// values that define the dequantization
					opb.write(q_min,32);
					opb.write(q_delta,32);
					opb.write(q_quant-1,4);
					opb.write(q_sequencep,1);
    
				{
					int quantvals=0;
					switch(maptype)
					{
						case 1:
							// a single column of (c->entries/c->dim) quantized values for
							// building a full value list algorithmically (square lattice)
							quantvals=maptype1_quantvals();
							break;
						case 2:
							// every value (c->entries*c->dim total) specified explicitly
							quantvals=entries*dim;
							break;
					}

					// quantized values
					for(i=0;i<quantvals;i++)
					{
						opb.write(Math.Abs(quantlist[i]),q_quant);
					}
				}
					break;
				default:
					// error case; we don't have any other map types now
					return(-1);
			}
			return(0);
		}
		/*
		*/

		// unpacks a codebook from the packet buffer into the codebook struct,
		// readies the codebook auxiliary structures for decode
		internal int unpack(csBuffer opb)
		{
			int i;
			//memset(s,0,sizeof(static_codebook));

			// make sure alignment is correct
			if(opb.read(24)!=0x564342)
			{
				//    goto _eofout;
				clear();
				return(-1); 
			}

			// first the basic parameters
			dim=opb.read(16);
			entries=opb.read(24);
			if(entries==-1)
			{
				//    goto _eofout;
				clear();
				return(-1); 
			}

			// codeword ordering.... length ordered or unordered?
			switch(opb.read(1))
			{
				case 0:
					// unordered
					lengthlist=new int[entries];

					// allocated but unused entries?
					if(opb.read(1)!=0)
					{
						// yes, unused entries

						for(i=0;i<entries;i++)
						{
							if(opb.read(1)!=0)
							{
								int num=opb.read(5);
								if(num==-1)
								{
									//            goto _eofout;
									clear();
									return(-1); 
								}
								lengthlist[i]=num+1;
							}
							else
							{
								lengthlist[i]=0;
							}
						}
					}
					else
					{
						// all entries used; no tagging
						for(i=0;i<entries;i++)
						{
							int num=opb.read(5);
							if(num==-1)
							{
								//          goto _eofout;
								clear();
								return(-1); 
							}
							lengthlist[i]=num+1;
						}
					}
					break;
				case 1:
					// ordered
				{
					int length=opb.read(5)+1;
					lengthlist=new int[entries];

					for(i=0;i<entries;)
					{
						int num=opb.read(ilog(entries-i));
						if(num==-1)
						{
							//          goto _eofout;
							clear();
							return(-1); 
						}
						for(int j=0;j<num;j++,i++)
						{
							lengthlist[i]=length;
						}
						length++;
					}
				}
					break;
				default:
					// EOF
					return(-1);
			}
  
			// Do we have a mapping to unpack?
			switch((maptype=opb.read(4)))
			{
				case 0:
					// no mapping
					break;
				case 1:
				case 2:
					// implicitly populated value mapping
					// explicitly populated value mapping
					q_min=opb.read(32);
					q_delta=opb.read(32);
					q_quant=opb.read(4)+1;
					q_sequencep=opb.read(1);

				{
					int quantvals=0;
					switch(maptype)
					{
						case 1:
							quantvals=maptype1_quantvals();
							break;
						case 2:
							quantvals=entries*dim;
							break;
					}
      
					// quantized values
					quantlist=new int[quantvals];
					for(i=0;i<quantvals;i++)
					{
						quantlist[i]=opb.read(q_quant);
					}
					if(quantlist[quantvals-1]==-1)
					{
						//        goto _eofout;
						clear();
						return(-1); 
					}
				}
					break;
				default:
					//    goto _eofout;
					clear();
					return(-1); 
			}
			// all set
			return(0);
			//    _errout:
			//    _eofout:
			//    vorbis_staticbook_clear(s);
			//    return(-1); 
		}

		// there might be a straightforward one-line way to do the below
		// that's portable and totally safe against roundoff, but I haven't
		// thought of it.  Therefore, we opt on the side of caution
		internal int maptype1_quantvals()
		{
			int vals=(int)(Math.Floor(Math.Pow(entries,1.0/dim)));

			// the above *should* be reliable, but we'll not assume that FP is
			// ever reliable when bitstream sync is at stake; verify via integer
			// means that vals really is the greatest value of dim for which
			// vals^b->bim <= b->entries
			// treat the above as an initial guess
			while(true)
			{
				int acc=1;
				int acc1=1;
				for(int i=0;i<dim;i++)
				{
					acc*=vals;
					acc1*=vals+1;
				}
				if(acc<=entries && acc1>entries){	return(vals); }
				else
				{
					if(acc>entries){ vals--; }
					else{ vals++; }
				}
			}
		}
    
		internal void clear()
		{
			//  if(quantlist!=null)free(b->quantlist);
			//  if(lengthlist!=null)free(b->lengthlist);
			//  if(nearest_tree!=null){
			//    free(b->nearest_tree->ptr0);
			//    free(b->nearest_tree->ptr1);
			//    free(b->nearest_tree->p);
			//    free(b->nearest_tree->q);
			//    memset(b->nearest_tree,0,sizeof(encode_aux_nearestmatch));
			//    free(b->nearest_tree);
			//  }
			//  if(thresh_tree!=null){
			//    free(b->thresh_tree->quantthresh);
			//    free(b->thresh_tree->quantmap);
			//    memset(b->thresh_tree,0,sizeof(encode_aux_threshmatch));
			//    free(b->thresh_tree);
			//  }
			//  memset(b,0,sizeof(static_codebook));
		}

		// unpack the quantized list of values for encode/decode
		// we need to deal with two map types: in map type 1, the values are
		// generated algorithmically (each column of the vector counts through
		// the values in the quant vector). in map type 2, all the values came
		// in in an explicit list.  Both value lists must be unpacked
		internal float[] unquantize()
		{

			if(maptype==1 || maptype==2)
			{
				int quantvals;
				float mindel=float32_unpack(q_min);
				float delta=float32_unpack(q_delta);
				float[] r=new float[entries*dim];

				//System.err.println("q_min="+q_min+", mindel="+mindel);

				// maptype 1 and 2 both use a quantized value vector, but
				// different sizes
				switch(maptype)
				{
					case 1:
						// most of the time, entries%dimensions == 0, but we need to be
						// well defined.  We define that the possible vales at each
						// scalar is values == entries/dim.  If entries%dim != 0, we'll
						// have 'too few' values (values*dim<entries), which means that
						// we'll have 'left over' entries; left over entries use zeroed
						// values (and are wasted).  So don't generate codebooks like that
						quantvals=maptype1_quantvals();
						for(int j=0;j<entries;j++)
						{
							float last=0.0f;
							int indexdiv=1;
							for(int k=0;k<dim;k++)
							{
								int index=(j/indexdiv)%quantvals;
								float val=quantlist[index];
								val=Math.Abs(val)*delta+mindel+last;
								if(q_sequencep!=0)last=val;	  
								r[j*dim+k]=val;
								indexdiv*=quantvals;
							}
						}
						break;
					case 2:
						for(int j=0;j<entries;j++)
						{
							float last=0.0f;
							for(int k=0;k<dim;k++)
							{
								float val=quantlist[j*dim+k];
								//if((j*dim+k)==0){System.err.println(" | 0 -> "+val+" | ");}
								val=Math.Abs(val)*delta+mindel+last;
								if(q_sequencep!=0)last=val;	  
								r[j*dim+k]=val;
								//if((j*dim+k)==0){System.err.println(" $ r[0] -> "+r[0]+" | ");}
							}
						}
						//System.err.println("\nr[0]="+r[0]);
						break;
					default:
						break;
				}
				return(r);
			}
			return(null);
		}

		internal static int ilog(int v)
		{
			int ret=0;
			while(v!=0)
			{
				ret++;
				v = (int)((uint)v >> 1);
			}
			return(ret);
		}

		// 32 bit float (not IEEE; nonnormalized mantissa +
		// biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm 
		// Why not IEEE?  It's just not that important here.

		//static int VQ_FEXP=10;
		static int VQ_FMAN=21;
		static int VQ_FEXP_BIAS=768; // bias toward values smaller than 1.

		// doesn't currently guard under/overflow 
		internal static long float32_pack(float val)
		{
			uint sign=0;
			int exp;
			int mant;
			if(val<0)
			{
				sign = 0x80000000;
				val = -val;
			}
			exp=(int)Math.Floor(Math.Log(val)/Math.Log(2));
			mant=(int)Math.Round(Math.Pow(val,(VQ_FMAN-1)-exp));
			exp=(exp+VQ_FEXP_BIAS)<<VQ_FMAN;
			return((int)sign | exp | mant);
		}

		internal static float float32_unpack(int val)
		{
			float mant=val&0x1fffff;
			float sign=val&0x80000000;
			float exp =(uint)(val&0x7fe00000) >> VQ_FMAN;
			//System.err.println("mant="+mant+", sign="+sign+", exp="+exp);
			//if(sign!=0.0)mant= -mant;
			if((val&0x80000000)!=0)mant= -mant;
			//System.err.println("mant="+mant);
			return(ldexp(mant,((int)exp)-(VQ_FMAN-1)-VQ_FEXP_BIAS));
		}

		internal static float ldexp(float foo, int e)
		{
			return (float)(foo*Math.Pow(2, e));
		}
	}
}
